boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/elasticsearch/repository/CustomRestaurantESRepositoryImpl.java (1)

272-354: Documentation improvements needed

The added query example is helpful, but there are a few issues to address:

1. Typo in field name: "restautant_name" should be "restaurant_name"
2. Date format mismatch: Example shows "dd-MM-yyy'T'hh:mm:ss" but code uses "dd-MM-yyy"

-     * "restautant_name",
+     * "restaurant_name",

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/config/SwaggerConfig.java (1)

10-12: Good improvements to configuration class!

The changes align with Spring Boot best practices:

1. Setting proxyBeanMethods = false improves startup time and memory usage since this configuration doesn't require bean method interception
2. Reducing visibility to package-private is appropriate as this configuration doesn't need to be accessed outside its package

Consider applying these same optimizations to other @Configuration classes in the project for consistency and performance benefits.

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/config/DataStoreConfiguration.java (1)

28-28: LGTM! Good practice to make configuration classes package-private.

Making configuration classes package-private helps enforce proper modularity by preventing unintended access from other packages. This change aligns with the principle of encapsulation.

Consider applying this pattern consistently across all configuration classes in the application for better maintainability.

boot-mongodb-elasticsearch/src/test/java/com/example/mongoes/web/model/RestaurantRequestTest.java (1)

25-45: Enhance test coverage with additional scenarios.

While the basic serialization test is good, consider adding:

1. Edge cases (null values, empty lists)
2. Field validation tests
3. JSON structure verification
4. Custom field format validation (e.g., date format)

Example enhancement:

 @Test
 void serializeInCorrectFormat() throws IOException {
     // ... existing test code ...
     
     JsonContent<RestaurantRequest> json = jacksonTester.write(restaurantRequest);
     assertThat(json.getJson()).isNotNull();
+    // Verify JSON structure
+    assertThat(json).hasJsonPathNumberValue("$.id");
+    assertThat(json).hasJsonPathStringValue("$.name");
+    assertThat(json).hasJsonPathArrayValue("$.grades");
+    
+    // Verify field values
+    assertThat(json).extractingJsonPathNumberValue("$.id").isEqualTo(1);
+    assertThat(json).extractingJsonPathStringValue("$.name").isEqualTo("junitRestaurant");
 
     RestaurantRequest orderRequest = jacksonTester.parseObject(json.getJson());
     assertThat(orderRequest).isNotNull();
+    assertThat(orderRequest.getId()).isEqualTo(1L);
+    assertThat(orderRequest.getName()).isEqualTo("junitRestaurant");
 }
+
+@Test
+void shouldHandleNullValues() throws IOException {
+    RestaurantRequest request = new RestaurantRequest(1L, null, null, null, null, null);
+    JsonContent<RestaurantRequest> json = jacksonTester.write(request);
+    RestaurantRequest parsed = jacksonTester.parseObject(json.getJson());
+    assertThat(parsed.getName()).isNull();
+    assertThat(parsed.getGrades()).isNull();
+}

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Check for any existing tests covering these range queries

# Search for test files that might cover these methods
rg -l "searchRestaurantIdRange|searchDateRange" --type java

#!/bin/bash
# Check the test implementations to verify range query testing
rg "searchRestaurantIdRange|searchDateRange" -B 2 -A 10 boot-mongodb-elasticsearch/src/test/java/com/example/mongoes/elasticsearch/repository/RestaurantESRepositoryIntegrationTest.java

#!/bin/bash
# Search for similar imports in the codebase and changelog
rg -l "SpringDataJacksonConfiguration" | grep -v "WebFluxConfig.java"

# Check Spring Boot 3.4.0 changelog for related changes
gh api repos/spring-projects/spring-boot/releases/tags/v3.4.0 --jq '.body' | grep -i "jackson"

#!/bin/bash
# Check the test file that imports SpringDataJacksonConfiguration
cat boot-mongodb-elasticsearch/src/test/java/com/example/mongoes/web/model/RestaurantRequestTest.java

# Look for Jackson-related configuration or beans in the codebase
rg -l "ObjectMapper|Jackson" --type java

# Check if there are any explicit Jackson configurations
ast-grep --pattern 'class $_ implements WebFluxConfigurer { $$$ }'

#!/bin/bash
# Check for compatibility issues in dependency upgrades

# Check springdoc-openapi release notes
echo "Checking springdoc-openapi 2.7.0 compatibility..."
gh api repos/springdoc/springdoc-openapi/releases/tags/v2.7.0 --jq '.body'

# Check for any reported issues
echo "Checking for reported issues..."
gh api graphql -f query='
{
  search(query: "repo:springdoc/springdoc-openapi is:issue label:bug springboot-3.4", type: ISSUE, first: 5) {
    nodes {
      ... on Issue {
        title
        url
        state
      }
    }
  }
}'

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/mongodb/repository/CustomChangeStreamResumeRepositoryImpl.java (1)

17-19: LGTM! Consider adding parameter validation.

The explicit constructor replacement for Lombok's @requiredargsconstructor is clean and appropriate. While Spring ensures non-null dependency injection, consider adding parameter validation as a defensive programming practice.

 public CustomChangeStreamResumeRepositoryImpl(ReactiveMongoTemplate reactiveMongoTemplate) {
+    if (reactiveMongoTemplate == null) {
+        throw new IllegalArgumentException("reactiveMongoTemplate must not be null");
+    }
     this.reactiveMongoTemplate = reactiveMongoTemplate;
 }

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/document/ChangeStreamResume.java (1)

8-28: Consider adding equals, hashCode, and toString methods.

As this is a MongoDB document class, it would be beneficial to implement:

1. equals/hashCode - for proper document comparison and collection operations
2. toString - for better debugging and logging

Here's a suggested implementation:

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof ChangeStreamResume that)) return false;
    return Objects.equals(id, that.id) && 
           Objects.equals(resumeTimestamp, that.resumeTimestamp);
}

@Override
public int hashCode() {
    return Objects.hash(id, resumeTimestamp);
}

@Override
public String toString() {
    return "ChangeStreamResume{" +
           "id='" + id + '\'' +
           ", resumeTimestamp=" + resumeTimestamp +
           '}';
}

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/document/Grades.java (1)

22-61: Implementation looks good, consider adding equals/hashCode methods.

The manual implementation of constructors, getters, setters, and toString is correct and follows good practices. The use of StringJoiner for toString is particularly good.

Consider adding equals/hashCode methods to ensure proper object equality comparison, especially important for collections and caching. Here's a suggested implementation:

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Grades grades)) return false;
    return Objects.equals(grade, grades.grade) &&
           Objects.equals(date, grades.date) &&
           Objects.equals(score, grades.score);
}

@Override
public int hashCode() {
    return Objects.hash(grade, date, score);
}

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/document/Restaurant.java (1)

50-128: Consider adding equals/hashCode methods for proper object comparison.

While the current implementation of constructors, getters, setters, and toString is correct, the class is missing equals/hashCode methods which are important for proper object comparison in collections.

Consider adding:

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Restaurant that)) return false;
    return Objects.equals(id, that.id) &&
           Objects.equals(restaurantId, that.restaurantId) &&
           Objects.equals(name, that.name) &&
           Objects.equals(address, that.address) &&
           Objects.equals(borough, that.borough) &&
           Objects.equals(cuisine, that.cuisine) &&
           Objects.equals(grades, that.grades) &&
           Objects.equals(version, that.version);
}

@Override
public int hashCode() {
    return Objects.hash(id, restaurantId, name, address, borough, cuisine, grades, version);
}

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/web/controller/RestaurantController.java (1)

Line range hint 89-106: Consider making createRestaurant method fully reactive

The method currently mixes reactive and non-reactive code. Consider making it fully reactive for consistency with other endpoints.

-    @PostMapping
-    public ResponseEntity<GenericMessage> createRestaurant(
-            @RequestBody RestaurantRequest restaurantRequest) {
-        return ResponseEntity.created(
-                        URI.create(
-                                String.format(
-                                        "/restaurant/%s",
-                                        this.restaurantService
-                                                .createRestaurant(restaurantRequest)
-                                                .map(Restaurant::getName))))
-                .body(
-                        new GenericMessage(
-                                "restaurant with name %s created"
-                                        .formatted(restaurantRequest.name())));
-    }
+    @PostMapping
+    public Mono<ResponseEntity<GenericMessage>> createRestaurant(
+            @RequestBody RestaurantRequest restaurantRequest) {
+        return this.restaurantService
+                .createRestaurant(restaurantRequest)
+                .map(restaurant -> ResponseEntity
+                        .created(URI.create("/restaurant/" + restaurant.getName()))
+                        .body(new GenericMessage("restaurant with name %s created"
+                                .formatted(restaurantRequest.name()))));
+    }

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/web/controller/SearchController.java (1)

Line range hint 1-156: Consider adding OpenAPI documentation

The controller has multiple complex search endpoints with various parameters. Consider adding OpenAPI documentation using @operation and @parameter annotations to improve API discoverability and usage.

Example for one endpoint:

@Operation(summary = "Search restaurants within range", 
          description = "Find restaurants within specified distance from given coordinates")
@GetMapping("/search/restaurant/withInRange")
public Flux<ResultData> searchRestaurantsWithInRange(
        @Parameter(description = "Latitude coordinate") @RequestParam Double lat,
        @Parameter(description = "Longitude coordinate") @RequestParam Double lon,
        @Parameter(description = "Distance from coordinates") @RequestParam Double distance,
        @Parameter(description = "Unit of distance (km/mi)", example = "km") 
        @RequestParam(defaultValue = "km", required = false) String unit)

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/web/service/SearchService.java (1)

Line range hint 116-156: Consider extracting aggregation logic to separate class

The aggregation logic is complex and could benefit from being extracted into a dedicated class for better maintainability and testability.

Consider creating an AggregationProcessor class:

@Component
class AggregationProcessor {
    public Map<String, Map<String, Long>> processAggregations(
            Map<String, ElasticsearchAggregation> aggregationMap) {
        // Move existing aggregation logic here
    }
}

boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/web/service/RestaurantService.java (2)

51-60: LGTM! Well-structured constructor replacing @requiredargsconstructor

The constructor implementation:

• Uses constructor injection (Spring recommended approach)
• Properly initializes all dependencies
• Has a clear parameter order

Consider adding @NonNull annotations to the constructor parameters to ensure null-safety, especially since we're moving away from Lombok's built-in null checks.

---

Line range hint 1-300: Consider splitting responsibilities for better maintainability

While the implementation is functional, the service class has multiple responsibilities:

• MongoDB operations
• Elasticsearch operations
• Change stream processing
• Data transformation

Consider splitting this into separate services:

• RestaurantMongoService: MongoDB operations
• RestaurantSearchService: Elasticsearch operations
• RestaurantStreamProcessor: Change stream processing
• RestaurantMapper: Data transformation logic

This would:

• Improve maintainability
• Make the code more testable
• Follow the Single Responsibility Principle

Would you like me to provide an example of how to refactor this into separate services?

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Check for any breaking changes in annotation usage
rg -l "@Document|@org.springframework.data.elasticsearch.annotations.Document" | xargs ast-grep --pattern 'class $_ {
  $$$
  @$_("$_")
  $$$
}'

# Check pom.xml for dependency versions
rg -A 5 "spring-boot-starter-data-mongodb|spring-boot-starter-data-elasticsearch" pom.xml

#!/bin/bash
# Check pom.xml for Spring Boot version and dependencies
rg -A 5 "<parent>|<artifactId>spring-boot" pom.xml

# Check for MongoDB and Elasticsearch dependencies
cat pom.xml

# Check for any other Restaurant classes or similar dual-indexed entities
fd -e java -x grep -l "org.springframework.data.elasticsearch.annotations.Document" {}
fd -e java -x grep -l "org.springframework.data.mongodb.core.mapping.Document" {}

#!/bin/bash
# Check the module-specific pom.xml for Spring Boot version and dependencies
cat boot-mongodb-elasticsearch/pom.xml

# Check for any application.properties/yaml files that might have relevant MongoDB/Elasticsearch configuration
fd -e properties -e yml -e yaml -x cat {} boot-mongodb-elasticsearch/src/main/resources/

#!/bin/bash
# Check application.properties/yaml for MongoDB and Elasticsearch configuration
find boot-mongodb-elasticsearch/src/main/resources -type f -name "application*.yml" -o -name "application*.yaml" -o -name "application*.properties" -exec cat {} \;

# Check for any test files that might show configuration
find boot-mongodb-elasticsearch/src/test -type f -name "*Test*.java" -exec grep -l "MongoDB\|Elasticsearch" {} \;

# Look for configuration classes
find boot-mongodb-elasticsearch/src/main/java -type f -name "*Config*.java" -exec cat {} \;

#!/bin/bash
# Check if tests exist for the aggregation logic
rg -l "class.*SearchServiceTest" 
rg "test.*aggregate.*search" 

#!/bin/bash
# Let's try a broader search for test files in the project
fd "Test.*\.java$"

# Also search for any test files containing "search" or "aggregate"
rg -l "class.*Test.*\{" | rg -l "search|aggregate" -i

#!/bin/bash
# Let's search specifically in the boot-mongodb-elasticsearch module for test files related to search and aggregation
fd "Test.*\.java$" boot-mongodb-elasticsearch/src/test/

# Let's also look for test content specifically related to search aggregation in this module
rg -l "test.*[aA]ggregat" boot-mongodb-elasticsearch/src/test/
rg -C 3 "void test.*[sS]earch" boot-mongodb-elasticsearch/src/test/

#!/bin/bash
# Let's examine the content of the repository integration test file to see if there are any search/aggregation tests
rg -C 5 "search|aggregat" boot-mongodb-elasticsearch/src/test/java/com/example/mongoes/elasticsearch/repository/RestaurantESRepositoryIntegrationTest.java

# Also check the controller test for search/aggregation related tests
rg -C 5 "search|aggregat" boot-mongodb-elasticsearch/src/test/java/com/example/mongoes/web/controller/RestaurantControllerIntTest.java

#!/bin/bash
# Description: Check for potential transaction-related changes in Spring Boot 3.4.0

# Search for other @Transactional usages with reactive types
rg -l "import org.springframework.transaction.annotation.Transactional" | xargs rg "@Transactional.*Mono|Flux"

# Check for any reactive MongoDB configuration
rg -l "ReactiveMongoTransactionManager|ReactiveMongoTemplate"

#!/bin/bash
# Check for MongoDB configuration and transaction setup
ast-grep --pattern 'class DataStoreConfiguration {
  $$$
}'  boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/config/DataStoreConfiguration.java

# Check for transaction usage in RestaurantService
ast-grep --pattern '@Transactional
$$$
public $_ $_($$$) {
  $$$
}' boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/web/service/RestaurantService.java

# Check for any reactive transaction configuration
rg -A 5 "@EnableTransactionManagement|@EnableReactiveMongoRepositories"

#!/bin/bash
# Check for MongoDB client and transaction configuration
rg -A 10 "ReactiveMongoClientFactoryBean|MongoTransactionManager|@Bean.*ReactiveMongoTemplate" boot-mongodb-elasticsearch/src/main/java/com/example/mongoes/config/DataStoreConfiguration.java

# Check for any transaction-related properties in application properties/yaml
fd -e yml -e yaml -e properties | xargs rg -i "spring\.data\.mongodb.*transaction|mongodb.*transaction"